d3c583fffabd37f382d695d4d7be0c7921469c35,jps/model/src/org/jetbrains/ether/dependencyView/Mappings.java,Mappings,differentiate,#Mappings#Collection#Collection#Collection#Collection#,492
Before Change
}
else if (d.base() != Difference.NONE || throwsChanged) {
if (d.packageLocalOn()) {
final UsageRepr.Usage usage = m.createUsage(myContext, it.name);
affectedUsages.add(usage);
usageConstraints.put(usage, u.new PackageConstraint(it.getPackageName()));
}
After Change
self.appendDependents(pastClasses, dependants);
final Set<UsageRepr.Usage> affectedUsages = new HashSet<UsageRepr.Usage>();
final Set<UsageRepr.AnnotationUsage> annotationQuery = new HashSet<UsageRepr.AnnotationUsage>();
final Map<UsageRepr.Usage, Util.UsageConstraint> usageConstraints = new HashMap<UsageRepr.Usage, Util.UsageConstraint>();
final Difference.Specifier<ClassRepr> classDiff = Difference.make(pastClasses, classes);
for (Pair<ClassRepr, Difference> changed : classDiff.changed()) {
final ClassRepr it = changed.first;
final ClassRepr.Diff diff = (ClassRepr.Diff)changed.second;
final int addedModifiers = diff.addedModifiers();
final int removedModifiers = diff.removedModifiers();
final boolean superClassChanged = (diff.base() & Difference.SUPERCLASS) > 0;
final boolean interfacesChanged = !diff.interfaces().unchanged();
final boolean signatureChanged = (diff.base() & Difference.SIGNATURE) > 0;
if (superClassChanged || interfacesChanged || signatureChanged) {
final boolean extendsChanged = superClassChanged && !diff.extendsAdded();
final boolean interfacesRemoved = interfacesChanged && !diff.interfaces().removed().isEmpty();
u.affectSubclasses(it.name, affectedFiles, affectedUsages, dependants, extendsChanged || interfacesRemoved || signatureChanged);
}
if ((diff.addedModifiers() & Opcodes.ACC_INTERFACE) > 0 || (diff.removedModifiers() & Opcodes.ACC_INTERFACE) > 0) {
affectedUsages.add(it.createUsage());
}
if (it.isAnnotation() && it.policy == RetentionPolicy.SOURCE) {
return false;
}
if ((addedModifiers & Opcodes.ACC_PROTECTED) > 0) {
final UsageRepr.Usage usage = it.createUsage();
affectedUsages.add(usage);
usageConstraints.put(usage, u.new InheritanceConstraint(it.name));
}
if (diff.packageLocalOn()) {
final UsageRepr.Usage usage = it.createUsage();
affectedUsages.add(usage);
usageConstraints.put(usage, u.new PackageConstraint(it.getPackageName()));
}
if ((addedModifiers & Opcodes.ACC_FINAL) > 0 || (addedModifiers & Opcodes.ACC_PRIVATE) > 0) {
affectedUsages.add(it.createUsage());
}
if ((addedModifiers & Opcodes.ACC_ABSTRACT) > 0) {
affectedUsages.add(UsageRepr.createClassNewUsage(myContext, it.name));
}
if ((addedModifiers & Opcodes.ACC_STATIC) > 0 ||
(removedModifiers & Opcodes.ACC_STATIC) > 0 ||
(addedModifiers & Opcodes.ACC_ABSTRACT) > 0) {
affectedUsages.add(UsageRepr.createClassNewUsage(myContext, it.name));
}
if (it.isAnnotation()) {
if (diff.retentionChanged()) {
affectedUsages.add(it.createUsage());
}
else {
final Collection<ElementType> removedtargets = diff.targets().removed();
if (removedtargets.contains(ElementType.LOCAL_VARIABLE)) {
return false;
}
if (!removedtargets.isEmpty()) {
annotationQuery.add((UsageRepr.AnnotationUsage)UsageRepr
.createAnnotationUsage(myContext, TypeRepr.createClassType(myContext, it.name), null, removedtargets));
}
for (MethodRepr m : diff.methods().added()) {
if (!m.hasValue()) {
affectedUsages.add(it.createUsage());
}
}
}
}
for (MethodRepr m : diff.methods().added()) {
if ((it.access & Opcodes.ACC_INTERFACE) > 0 || (m.access & Opcodes.ACC_ABSTRACT) > 0) {
u.affectSubclasses(it.name, affectedFiles, affectedUsages, dependants, false);
}
}
for (MethodRepr m : diff.methods().removed()) {
final Collection<Pair<MethodRepr, ClassRepr>> overridenMethods = u.findOverridenMethods(m, it);
final Collection<DependencyContext.S> propagated = u.propagateMethodAccess(m.name, it.name);
if (overridenMethods.size() == 0) {
u.affectMethodUsages(m, propagated, m.createUsage(myContext, it.name), affectedUsages, dependants);
}
if ((m.access & Opcodes.ACC_ABSTRACT) == 0) {
for (DependencyContext.S p : propagated) {
final ClassRepr s = u.reprByName(p);
if (s != null) {
final Collection<Pair<MethodRepr, ClassRepr>> overridenInS = u.findOverridenMethods(m, s);
overridenInS.addAll(overridenMethods);
boolean allAbstract = true;
boolean visited = false;
for (Pair<MethodRepr, ClassRepr> pp : overridenInS) {
if (pp.second.name.equals(it.name)) {
continue;
}
visited = true;
allAbstract = ((pp.first.access & Opcodes.ACC_ABSTRACT) > 0) || ((pp.second.access & Opcodes.ACC_INTERFACE) > 0);
if (!allAbstract) {
break;
}
}
if (allAbstract && visited) {
final DependencyContext.S source = myClassToSourceFile.get(p);
if (source != null) {
affectedFiles.add(new File(myContext.getValue(source)));
}
}
}
}
}
}
for (Pair<MethodRepr, Difference> mr : diff.methods().changed()) {
final MethodRepr m = mr.first;
final MethodRepr.Diff d = (MethodRepr.Diff)mr.second;
final boolean throwsChanged = (d.exceptions().added().size() > 0) || (d.exceptions().changed().size() > 0);
if (it.isAnnotation()) {
if (d.defaultRemoved()) {
final List<DependencyContext.S> l = new LinkedList<DependencyContext.S>();
l.add(m.name);
annotationQuery.add((UsageRepr.AnnotationUsage)UsageRepr
.createAnnotationUsage(myContext, TypeRepr.createClassType(myContext, it.name), l, null));
}
}
else if (d.base() != Difference.NONE || throwsChanged) {
final Collection<DependencyContext.S> propagated = u.propagateMethodAccess(m.name, it.name);
if (d.packageLocalOn()) {
final Set<UsageRepr.Usage> usages = new HashSet<UsageRepr.Usage>();
u.affectMethodUsages(m, propagated, m.createUsage(myContext, it.name), usages, dependants);
for (UsageRepr.Usage usage : usages) {
usageConstraints.put(usage, u.new InheritanceConstraint(it.name));
}
affectedUsages.addAll(usages);
}
if ((d.base() & Difference.TYPE) > 0 || (d.base() & Difference.SIGNATURE) > 0 || throwsChanged) {
u.affectMethodUsages(m, propagated, m.createUsage(myContext, it.name), affectedUsages, dependants);
}
else if ((d.base() & Difference.ACCESS) > 0) {
if ((d.addedModifiers() & Opcodes.ACC_STATIC) > 0 ||
(d.removedModifiers() & Opcodes.ACC_STATIC) > 0 ||
(d.addedModifiers() & Opcodes.ACC_PRIVATE) > 0) {
u.affectMethodUsages(m, propagated, m.createUsage(myContext, it.name), affectedUsages, dependants);
if ((d.addedModifiers() & Opcodes.ACC_STATIC) > 0) {
u.affectSubclasses(it.name, affectedFiles, affectedUsages, dependants, false);
}
}
else {
if ((d.addedModifiers() & Opcodes.ACC_FINAL) > 0 ||
(d.addedModifiers() & Opcodes.ACC_PUBLIC) > 0 ||
(d.addedModifiers() & Opcodes.ACC_ABSTRACT) > 0) {
u.affectSubclasses(it.name, affectedFiles, affectedUsages, dependants, false);
}
if ((d.addedModifiers() & Opcodes.ACC_PROTECTED) > 0 && !((d.removedModifiers() & Opcodes.ACC_PRIVATE) > 0)) {
final Set<UsageRepr.Usage> usages = new HashSet<UsageRepr.Usage>();
u.affectMethodUsages(m, propagated, m.createUsage(myContext, it.name), usages, dependants);
for (UsageRepr.Usage usage : usages) {
usageConstraints.put(usage, u.new InheritanceConstraint(it.name));